#!/usr/bin/env node
/**
 * Phase 5: 标准模板对照验证器
 *
 * 用途：确保生成的组件代码严格遵循 Resources/templates/ 中的标准模板
 * 执行时机：Phase 5 Step 1.5，在 ChainValidator 之前
 *
 * 常见错误检测：
 * - 字段命名不一致（backgroundColor vs bgColor）
 * - bgStyle 实现模式偏差（useMemo vs 直接对象）
 * - Less 文件外层容器属性污染
 * - 配置面板职责混乱
 */

const fs = require('fs');
const path = require('path');

const COLORS = {
  RED: '\x1b[31m',
  GREEN: '\x1b[32m',
  YELLOW: '\x1b[33m',
  BLUE: '\x1b[34m',
  RESET: '\x1b[0m',
};

function log(color, message) {
  console.log(`${color}${message}${COLORS.RESET}`);
}

function validateTemplateCompliance(componentName) {
  log(COLORS.BLUE, `\n=== Phase 5 Step 1.5: 标准模板对照验证 ===`);
  log(COLORS.BLUE, `组件: ${componentName}`);
  log(COLORS.BLUE, `对照模板: Resources/templates/component-style-standard-pattern.md\n`);

  const errors = [];
  const warnings = [];

  // 1. 检查 FieldNode Props 字段命名
  log(COLORS.YELLOW, '检查 FieldNode Props 字段命名...');
  const fieldsPath = path.join(process.cwd(), 'src/components/editor/schema/fields/aiComponents.ts');

  if (fs.existsSync(fieldsPath)) {
    const fieldsContent = fs.readFileSync(fieldsPath, 'utf-8');

    // 检查是否包含目标组件
    if (!fieldsContent.includes(`type: '${componentName}'`)) {
      errors.push(`FieldNode: 未找到 ${componentName} 定义`);
    } else {
      // 提取组件的 props 部分
      const componentMatch = fieldsContent.match(
        new RegExp(`type: '${componentName}'[\\s\\S]*?props: \\{([\\s\\S]*?)\\n  \\},`, 'm')
      );

      if (componentMatch) {
        const propsContent = componentMatch[1];

        // 检查错误命名
        if (propsContent.includes('backgroundColor:') && !propsContent.includes('bgColor:')) {
          errors.push('FieldNode: 使用了 backgroundColor 而非标准的 bgColor');
        }
        if (propsContent.includes('backgroundColorOpacity:') && !propsContent.includes('bgColorOpacity:')) {
          errors.push('FieldNode: 使用了 backgroundColorOpacity 而非标准的 bgColorOpacity');
        }
        if (propsContent.includes('backgroundImage:') && !propsContent.includes('bgImg:')) {
          errors.push('FieldNode: 使用了 backgroundImage 而非标准的 bgImg');
        }

        // 检查必需字段存在
        const requiredFields = [
          'hasBg',
          'bgType',
          'bgColor',
          'bgColorOpacity',
          'bgImg',
          'topMargin',
          'bottomMargin',
          'horizontalOutterMargin',
          'topPadding',
          'bottomPadding',
          'horizontalInnerPadding',
        ];

        for (const field of requiredFields) {
          if (!propsContent.includes(`${field}:`)) {
            errors.push(`FieldNode: 缺少必需字段 ${field}`);
          }
        }

        // 检查 hasBg 是否使用字符串
        if (propsContent.match(/hasBg:\s*true/) || propsContent.match(/hasBg:\s*false/)) {
          errors.push("FieldNode: hasBg 应使用字符串 'Y'/'N' 而非布尔值");
        }
      }
    }
  } else {
    errors.push(`FieldNode: 文件不存在 ${fieldsPath}`);
  }

  // 2. 检查 Preview 组件
  log(COLORS.YELLOW, '检查 Preview 组件 bgStyle 实现模式...');
  const previewPath = path.join(
    process.cwd(),
    `src/components/editor/schema/preview/components/${componentName}/index.tsx`
  );

  if (fs.existsSync(previewPath)) {
    const previewContent = fs.readFileSync(previewPath, 'utf-8');

    // 检查是否使用 HexToRGB
    if (!previewContent.includes("import { HexToRGB }") && !previewContent.includes("import {HexToRGB}")) {
      errors.push('Preview: 未导入 HexToRGB 工具函数');
    }

    if (!previewContent.includes('HexToRGB(bgColor')) {
      errors.push('Preview: 未使用 HexToRGB(bgColor, bgColorOpacity)');
    }

    // 检查是否使用 useMemo 包裹 bgStyle
    if (previewContent.includes('useMemo(() =>') && previewContent.includes('marginTop:')) {
      warnings.push('Preview: bgStyle 不建议使用 useMemo 包裹（参考 JourneyPlanListProd）');
    }

    // 检查 visible 控制
    if (!previewContent.includes("hidden: !visible") && !previewContent.includes("hidden:!visible")) {
      warnings.push('Preview: 建议使用 className={cl(styles.carouselBox, { hidden: !visible })} 控制可见性');
    }

    // 检查是否直接从 props 解构
    if (previewContent.includes('const { value } = props') || previewContent.includes('{ value: Props }')) {
      errors.push('Preview: 应直接从 props 解构，而非使用 { value } 包装');
    }

    // 检查 bgImg 命名
    if (previewContent.includes('backgroundImage?.src') && !previewContent.includes('bgImg?.src')) {
      errors.push('Preview: 应使用 bgImg?.src 而非 backgroundImage?.src');
    }
  } else {
    errors.push(`Preview: 文件不存在 ${previewPath}`);
  }

  // 3. 检查 Less 文件
  log(COLORS.YELLOW, '检查 Less 文件外层容器属性...');
  const lessPath = path.join(
    process.cwd(),
    `src/components/editor/schema/preview/components/${componentName}/index.less`
  );

  if (fs.existsSync(lessPath)) {
    const lessContent = fs.readFileSync(lessPath, 'utf-8');

    // 检查外层容器是否设置禁止属性
    // 匹配 .wrap 或组件主类名
    const wrapMatch = lessContent.match(/\.wrap\s*\{([^}]+)\}/s) ||
                      lessContent.match(new RegExp(`\\.${componentName.toLowerCase()}[^{]*\\{([^}]+)\\}`, 'si'));

    if (wrapMatch) {
      const wrapContent = wrapMatch[1];

      // 检查禁止属性（注意排除子选择器中的属性）
      const lines = wrapContent.split('\n');
      for (const line of lines) {
        // 跳过注释和子选择器
        if (line.trim().startsWith('//') || line.trim().startsWith('.') || line.trim().startsWith('&')) {
          continue;
        }

        if (/^\s+padding\s*:/m.test(line) && !line.includes('//')) {
          errors.push('Less: 外层容器设置了 padding（会覆盖 bgStyle）');
        }
        if (/^\s+margin\s*:/m.test(line) && !line.includes('//')) {
          errors.push('Less: 外层容器设置了 margin（会覆盖 bgStyle）');
        }
        if (/^\s+background\s*:/m.test(line) && !line.includes('//')) {
          errors.push('Less: 外层容器设置了 background（会覆盖 bgStyle）');
        }
        if (/^\s+width\s*:\s*\d+px/m.test(line) && !line.includes('//')) {
          warnings.push('Less: 外层容器设置了固定 width（可能影响响应式）');
        }
        if (/^\s+height\s*:\s*\d+px/m.test(line) && !line.includes('//')) {
          warnings.push('Less: 外层容器设置了固定 height');
        }
      }
    }
  } else {
    warnings.push(`Less: 文件不存在 ${lessPath}`);
  }

  // 4. 检查配置面板职责划分
  log(COLORS.YELLOW, '检查配置面板职责划分...');

  const basicInfoPath = path.join(
    process.cwd(),
    `src/components/editor/Right/renderBasicInfo/render${componentName}.tsx`
  );

  if (fs.existsSync(basicInfoPath)) {
    const basicInfoContent = fs.readFileSync(basicInfoPath, 'utf-8');

    // 检查是否在 Content 面板中包含颜色选择器（Style 字段）
    const colorPickerMatches = basicInfoContent.match(/ColorPicker/g) || [];
    if (colorPickerMatches.length > 0) {
      // 检查是否有非内容相关的颜色配置
      const styleColorFields = [
        'subtitleFontColor',
        'axisLabelColor',
        'gridLineColor',
        'popoverBackgroundColor',
        'popoverDataFontColor',
        'popoverLabelFontColor',
        'chartLineColor',
        'chartAreaColor',
      ];

      for (const field of styleColorFields) {
        if (basicInfoContent.includes(field)) {
          errors.push(`配置面板: ${field} 应放在 TitleStyle 面板而非 Content 面板`);
        }
      }
    }
  }

  // 输出结果
  console.log('\n');

  if (errors.length === 0 && warnings.length === 0) {
    log(COLORS.GREEN, '✅ 模板合规性检查通过！');
    log(COLORS.GREEN, '所有字段命名和实现模式符合标准。');
  } else {
    if (errors.length > 0) {
      log(COLORS.RED, `❌ 发现 ${errors.length} 个错误：`);
      errors.forEach((err, i) => {
        log(COLORS.RED, `  ${i + 1}. ${err}`);
      });
    }

    if (warnings.length > 0) {
      log(COLORS.YELLOW, `\n⚠️  发现 ${warnings.length} 个警告：`);
      warnings.forEach((warn, i) => {
        log(COLORS.YELLOW, `  ${i + 1}. ${warn}`);
      });
    }

    if (errors.length > 0) {
      log(COLORS.RED, '\n建议操作：');
      log(COLORS.RED, '1. 阅读 Resources/templates/component-style-standard-pattern.md');
      log(COLORS.RED, '2. 对照 JourneyPlanListProd 实现进行修复');
      log(COLORS.RED, '3. 修复后重新运行此验证器');
    }
  }

  // 生成报告
  const report = {
    timestamp: new Date().toISOString(),
    componentName,
    status: errors.length > 0 ? 'FAILED' : warnings.length > 0 ? 'WARNING' : 'PASSED',
    errors,
    warnings,
    referenceTemplates: [
      'Resources/templates/component-style-standard-pattern.md',
      'Resources/knowledge-base/common-errors.md (ERR_P3_005, ERR_P3_006)',
    ],
  };

  const reportPath = path.join(process.cwd(), 'phase5/template-compliance-report.json');
  const reportDir = path.dirname(reportPath);

  if (!fs.existsSync(reportDir)) {
    fs.mkdirSync(reportDir, { recursive: true });
  }

  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
  log(COLORS.BLUE, `\n报告已生成: ${reportPath}`);

  return errors.length === 0;
}

// 主函数
const componentName = process.argv[2];

if (!componentName) {
  log(COLORS.RED, '用法: node scripts/phase5/template-compliance-validator.js <ComponentName>');
  log(COLORS.RED, '示例: node scripts/phase5/template-compliance-validator.js UsageTrendsProd2');
  process.exit(1);
}

const success = validateTemplateCompliance(componentName);
process.exit(success ? 0 : 1);
